const mongoose = require('mongoose');
const deviceShe = require('../db/deviceShe');
const dictMod = require('../db/dictMod');
const orderMod = require('../db/orderMod');

/**
 * 登录成功后的设备分配逻辑
 * @param {string} orderNumber - 订单号
 * @param {Object} opData - 登录成功后的OP数据
 * @returns {Promise<Object>} 分配结果
 */
async function allocateDevicesAfterLogin(orderNumber, opData) {
    try {
        console.log(`开始为订单 ${orderNumber} 分配设备`);
        
        // 查找订单
        const order = await orderMod.findOne({ orderNumber });
        if (!order) {
            throw new Error('订单不存在');
        }
        
        const userName = order.createUserName;
        console.log(`订单 ${orderNumber} 的创建人是: ${userName}`);
        
        // 构建设备模型
        const deviceMod = mongoose.model('device_' + userName, deviceShe);
        
        // 查询当前空闲任务设备数量
        const idleTaskDevicesCount = await deviceMod.countDocuments({
            deviceType: '任务设备',
            taskStatus: '空闲'
        });
        
        console.log(`当前空闲任务设备数量: ${idleTaskDevicesCount}`);
        
        // 从字典表获取最小空闲设备数量配置
        let minIdleDevices = 1; // 默认值
        try {
            const dictConfig = await dictMod.findOne({ name: 'min_ldle_devices' });
            console.log(dictConfig)
            if (dictConfig && dictConfig.value) {
                minIdleDevices = parseInt(dictConfig.value) || 1;
            }
        } catch (error) {
            console.log('获取min_ldle_devices配置失败，使用默认值1:', error.message);
        }
        
        console.log(`最小空闲设备数量配置: ${minIdleDevices}`);
        
        // 分配任务设备
        const taskDevice = await allocateTaskDevice(deviceMod, orderNumber, opData);
        if (!taskDevice) {
            throw new Error('没有可用的任务设备');
        }
        
        let companionDevice = null;
        
        // 检查是否需要分配陪玩设备
        console.log(`当前空闲任务设备数量: ${idleTaskDevicesCount} ${minIdleDevices}`);
        let idleCompanionDevices = null
        if (idleTaskDevicesCount > minIdleDevices) {
            console.log(`空闲设备数量(${idleTaskDevicesCount})大于最小值(${minIdleDevices})，尝试分配陪玩设备`);
            
            // 查找空闲的陪玩设备
            idleCompanionDevices = await deviceMod.find({
                deviceType: '陪玩设备',
                taskStatus: '空闲'
            }).limit(1);
            
            if (idleCompanionDevices.length > 0) {
                companionDevice = await allocateCompanionDevice(deviceMod, orderNumber, idleCompanionDevices[0]);
                console.log(`已分配陪玩设备: ${companionDevice.deviceName}`);
            } else {
                console.log('没有空闲的陪玩设备，只分配任务设备');
            }
        } else {
            console.log(`空闲设备数量(${idleTaskDevicesCount})不足最小值(${minIdleDevices})，不分配陪玩设备`);
        }
        
        return {
            success: true,
            taskDevice: taskDevice,
            companionDevice: companionDevice,
            idleCompanionDevice:idleCompanionDevices.length > 0 ? idleCompanionDevices[0] : null,
            message: companionDevice ? '任务设备和陪玩设备分配成功' : '仅分配任务设备'
        };
        
    } catch (error) {
        console.error('设备分配失败:', error);
        return {
            success: false,
            error: error.message
        };
    }
}

/**
 * 分配任务设备
 * @param {Object} deviceMod - 设备模型
 * @param {string} orderNumber - 订单号
 * @param {Object} opData - OP数据
 * @returns {Promise<Object>} 分配的设备信息
 */
async function allocateTaskDevice(deviceMod, orderNumber, opData) {
    // 查找空闲的任务设备
    const idleTaskDevices = await deviceMod.find({
        deviceType: '任务设备',
        taskStatus: '空闲'
    }).limit(1);
    
    if (idleTaskDevices.length === 0) {
        throw new Error('没有空闲的任务设备');
    }
    
    const device = idleTaskDevices[0];
    
    // 更新设备状态
    await deviceMod.updateOne(
        { _id: device._id },
        {
            taskStatus: '忙碌',
            taskName: `订单${orderNumber}任务`
        }
    );
    
    // 通过WebSocket发送任务数据
    const { clients } = require('../routes/wsRouter');
    const taskData = {
        type: "deviceTask",
        serverData: {
            taskName: `任务设备任务`,
            taskData: {
                taskType:'qq_login',
                orderNumber: orderNumber,
                opData: opData,
            },
            timeStamp: Date.now()
        }
    };
    
    const ws = clients.get(device.socketId);
    if (ws && ws.readyState === 1) {
        ws.send(JSON.stringify(taskData));
        console.log(`已向任务设备 ${device.deviceName} 发送任务数据`);
    } else {
        console.log(`任务设备 ${device.deviceName} WebSocket连接异常`);
        // 恢复设备状态
        await deviceMod.updateOne(
            { _id: device._id },
            {
                taskStatus: '空闲',
                taskName: '无任务'
            }
        );
        throw new Error('任务设备连接异常');
    }
    
    return device;
}

/**
 * 分配陪玩设备
 * @param {Object} deviceMod - 设备模型
 * @param {string} orderNumber - 订单号
 * @param {Object} device - 设备信息
 * @returns {Promise<Object>} 分配的设备信息
 */
async function allocateCompanionDevice(deviceMod, orderNumber, device) {
    // 更新设备状态
    await deviceMod.updateOne(
        { _id: device._id },
        {
            taskStatus: '忙碌',
            taskName: `订单${orderNumber}陪玩任务`
        }
    );
    
    // 通过WebSocket发送陪玩任务数据
    const { clients } = require('../routes/wsRouter');
    const taskData = {
        type: "companionTask",
        serverData: {
            taskName: `陪玩设备任务`,
            taskData: {
                orderNumber: orderNumber,
            },
            timeStamp: Date.now()
        }
    };
    
    const ws = clients.get(device.socketId);
    if (ws && ws.readyState === 1) {
        ws.send(JSON.stringify(taskData));
        console.log(`已向陪玩设备 ${device.deviceName} 发送任务数据`);
    } else {
        console.log(`陪玩设备 ${device.deviceName} WebSocket连接异常`);
        // 恢复设备状态
        await deviceMod.updateOne(
            { _id: device._id },
            {
                taskStatus: '空闲',
                taskName: '无任务'
            }
        );
        // 陪玩设备连接异常不抛出错误，只记录日志
    }
    
    return device;
}

module.exports = {
    allocateDevicesAfterLogin
};